#ifndef SAFE_FFI_HEADERS_H
#define SAFE_FFI_HEADERS_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>

// 前向声明
typedef struct SafeZenrsConfig SafeZenrsConfig;
typedef uint64_t ZenrsCallbackId;
typedef struct SafeMemoryBuffer SafeMemoryBuffer;

// 错误处理
typedef enum {
    ZENRS_FFI_SUCCESS = 0,
    ZENRS_FFI_ERROR_BUFFER_TOO_SMALL,
    ZENRS_FFI_ERROR_INVALID_STRING,
    ZENRS_FFI_ERROR_KEY_NOT_FOUND,
    ZENRS_FFI_ERROR_TYPE_MISMATCH,
    ZENRS_FFI_ERROR_MEMORY_ALLOCATION,
    ZENRS_FFI_ERROR_CALLBACK_NOT_FOUND,
    ZENRS_FFI_ERROR_INVALID_PARAMETER,
    ZENRS_FFI_ERROR_INTERNAL,
    ZENRS_FFI_ERROR_SERIALIZATION,
    ZENRS_FFI_ERROR_DESERIALIZATION,
    ZENRS_FFI_ERROR_OUT_OF_BOUNDS,
} ZenrsFfiError;

// 获取最后一个错误信息
const char* zenrs_safe_get_last_error(void);

// 释放错误信息
void zenrs_safe_free_error(const char* error);

// 配置管理
// 创建配置对象
SafeZenrsConfig* zenrs_safe_create_config(void);

// 释放配置对象
void zenrs_safe_free_config(SafeZenrsConfig* config);

// 设置配置值 - 字符串
ZenrsFfiError zenrs_safe_config_set_string(
    SafeZenrsConfig* config,
    const char* key,
    const char* value
);

// 设置配置值 - 布尔值
ZenrsFfiError zenrs_safe_config_set_bool(
    SafeZenrsConfig* config,
    const char* key,
    bool value
);

// 设置配置值 - 无符号整数
ZenrsFfiError zenrs_safe_config_set_uint(
    SafeZenrsConfig* config,
    const char* key,
    uint64_t value
);

// 设置配置值 - 有符号整数
ZenrsFfiError zenrs_safe_config_set_int(
    SafeZenrsConfig* config,
    const char* key,
    int64_t value
);

// 设置配置值 - 浮点数
ZenrsFfiError zenrs_safe_config_set_float(
    SafeZenrsConfig* config,
    const char* key,
    double value
);

// 获取配置值 - 字符串
// 返回值：ZENRS_FFI_SUCCESS 表示成功，其他值表示失败
// value_buffer: 存储结果的缓冲区
// buffer_size: 缓冲区大小
// out_length: 实际字符串长度（可选）
ZenrsFfiError zenrs_safe_config_get_string(
    SafeZenrsConfig* config,
    const char* key,
    char* value_buffer,
    size_t buffer_size,
    size_t* out_length
);

// 获取配置值 - 布尔值
ZenrsFfiError zenrs_safe_config_get_bool(
    SafeZenrsConfig* config,
    const char* key,
    bool* value
);

// 获取配置值 - 无符号整数
ZenrsFfiError zenrs_safe_config_get_uint(
    SafeZenrsConfig* config,
    const char* key,
    uint64_t* value
);

// 获取配置值 - 有符号整数
ZenrsFfiError zenrs_safe_config_get_int(
    SafeZenrsConfig* config,
    const char* key,
    int64_t* value
);

// 获取配置值 - 浮点数
ZenrsFfiError zenrs_safe_config_get_float(
    SafeZenrsConfig* config,
    const char* key,
    double* value
);

// 检查配置是否包含指定的键
bool zenrs_safe_config_has_key(
    SafeZenrsConfig* config,
    const char* key
);

// 删除配置中的键
ZenrsFfiError zenrs_safe_config_remove(
    SafeZenrsConfig* config,
    const char* key
);

// 清除所有配置
ZenrsFfiError zenrs_safe_config_clear(
    SafeZenrsConfig* config
);

// 序列化配置
// 返回值：序列化后的字节数组，需要使用free释放
// out_size: 序列化后的大小
unsigned char* zenrs_safe_config_serialize(
    SafeZenrsConfig* config,
    size_t* out_size
);

// 反序列化配置
// 返回值：新创建的配置对象，需要使用zenrs_safe_free_config释放
SafeZenrsConfig* zenrs_safe_config_deserialize(
    const unsigned char* data,
    size_t data_size
);

// 字符串工具
// 获取字符串长度
size_t zenrs_safe_string_length(const char* str);

// 安全复制字符串
// 返回值：实际复制的字符数
size_t zenrs_safe_string_copy(
    char* dest,
    const char* src,
    size_t dest_size
);

// 比较字符串
// 返回值：0表示相等，负数表示dest小于src，正数表示dest大于src
int zenrs_safe_string_compare(
    const char* str1,
    const char* str2
);

// 回调管理
// 注册回调函数
// 返回值：回调ID
ZenrsCallbackId zenrs_safe_register_callback(
    void* user_data,
    void (*callback)(void* user_data, const char* input, char* output, size_t output_size, size_t* out_length)
);

// 执行回调函数
// 返回值：ZENRS_FFI_SUCCESS 表示成功，其他值表示失败
// output_buffer: 存储回调结果的缓冲区
// buffer_size: 缓冲区大小
// out_length: 实际输出长度（可选）
ZenrsFfiError zenrs_safe_execute_callback(
    ZenrsCallbackId callback_id,
    const char* input,
    char* output_buffer,
    size_t buffer_size,
    size_t* out_length
);

// 注销回调函数
void zenrs_safe_unregister_callback(ZenrsCallbackId callback_id);

// 内存缓冲区管理
// 创建内存缓冲区
SafeMemoryBuffer* zenrs_safe_create_buffer(size_t size);

// 释放内存缓冲区
void zenrs_safe_free_buffer(SafeMemoryBuffer* buffer);

// 获取缓冲区大小
size_t zenrs_safe_buffer_size(const SafeMemoryBuffer* buffer);

// 读取缓冲区数据
// 返回值：ZENRS_FFI_SUCCESS 表示成功，其他值表示失败
ZenrsFfiError zenrs_safe_buffer_read(
    const SafeMemoryBuffer* buffer,
    size_t offset,
    void* dest,
    size_t dest_size
);

// 写入缓冲区数据
// 返回值：ZENRS_FFI_SUCCESS 表示成功，其他值表示失败
ZenrsFfiError zenrs_safe_buffer_write(
    SafeMemoryBuffer* buffer,
    size_t offset,
    const void* src,
    size_t src_size
);

// 获取缓冲区数据指针（用于只读操作）
const void* zenrs_safe_buffer_get_read_ptr(const SafeMemoryBuffer* buffer);

// 获取缓冲区数据指针（用于读写操作）
void* zenrs_safe_buffer_get_write_ptr(SafeMemoryBuffer* buffer);

#ifdef __cplusplus
}
#endif

#endif // SAFE_FFI_HEADERS_H